package com.idea.zd.sys.design.factory;

//接口
interface MyInterface{

    void print();
}


class MyClassOne implements MyInterface{

    @Override
    public void print() {
        System.out.println("MyClassOne");
    }
}

class MyClassTow implements MyInterface{

    @Override
    public void print() {
        System.out.println("MyClassTow");
    }
}

//普通工厂类========普通工厂模式就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。
class MyFactory{

    public MyInterface produce(String type){
        if("One".equals(type)){
            return new MyClassOne();
        }else if("Tow".equals(type)){
            return new MyClassTow();
        }else{
            System.out.println("没有该类型");
            return null;
        }
    }
}
//多个方法工厂模块=======多个工厂方法模式，是对普通工厂方法模式的改进，多个工厂方法模式就是提供多个工厂方法，分别创建对象
class MyManyFactory{

    public MyInterface produceOne(){
        return new MyClassOne();
    }

    public MyInterface produceTow(){
        return new MyClassTow();
    }
}

//静态工厂类==========静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。
class MyStaticFactory{
    public static MyInterface produceOne(){
        return new MyClassOne();
    }

    public static MyInterface produceTow(){
        return new MyClassTow();
    }
}


//抽象工厂=======定义实现接口 抽象工厂模式就是创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码
interface Provider{
    MyInterface produce();
}

class MyFactoryOne implements Provider{

    @Override
    public MyInterface produce() {
        return new MyClassOne();
    }
}

class MyFactoryTow implements Provider{

    @Override
    public MyInterface produce() {
        return new MyClassTow();
    }
}

/**
 * 工厂模式，是通过工厂方法代替new操作的一种模式
 * 说明：车分为货车和小轿车，而车都能够行驶，所以可以定义一个车的接口，添加一个行驶的方法
 * 然后添加货车与小轿车的类并实现车的接口，并各自定义一些特有的属性，他建一个车的工厂类，根据传入的参数返回
 * 不同的车实例
 */
public class FactoryTest {
    public static void main(String [] args){
        //普通工厂Start
        MyFactory myFactory = new MyFactory();
        //根据参数返回实例
        MyInterface myInterface = myFactory.produce("One");
        myInterface.print();
        //普通工厂End

        //多方法工厂Start
        MyManyFactory myManyFactory = new MyManyFactory();
        MyInterface myInterface1 = myManyFactory.produceTow();
        myInterface1.print();
        //多方法工厂End

        //静态工厂类Start
        MyInterface myInterface2 = MyStaticFactory.produceOne();
        myInterface2.print();
        //静态工厂类End


        //抽象工厂Start
        Provider provider = new MyFactoryOne();
        MyInterface myInterface3 = provider.produce();
        myInterface3.print();
        //抽象工厂End
    }
}
